home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 August: Tool Chest / Apple_Developer_Group_August_1996_Tool_Chest.iso / Sample Code / Interapplication Communication / MenuScripter 3.1 / Sources / MSUtils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-20  |  15.5 KB  |  586 lines  |  [TEXT/MPS ]
  1. /*
  2.     MSUtils.c
  3.     
  4.     Version 3.1
  5.     
  6.     Copyright © 1995 Apple Computer, Inc., all rights reserved.
  7.     
  8.     MenuScripter by Nigel Humphreys and Jon Lansdell
  9.     AppleEvent to script extensions by Greg Sutton
  10. */
  11.  
  12.  
  13.  
  14. #include <PLStringFuncs.h>
  15. #include <Events.h>
  16. #include <Traps.h>
  17. #include <Dialogs.h>
  18. #include <Fonts.h>
  19. #include <Packages.h>
  20. #include <AppleEvents.h>
  21. #include <TextUtils.h>
  22. #include "MSUtils.h"
  23.  
  24. /**-----------------------------------------------------------------------
  25.         Name:             LesserOf
  26.         Purpose:        Returns the Lesser of two longints.
  27.     -----------------------------------------------------------------------**/
  28. #pragma segment Utils
  29.         
  30. pascal long LesserOf(long A, long B)
  31.  {
  32.    if (A<B)
  33.        return(A);
  34.      else
  35.        return(B);
  36.  }   /*LesserOf*/
  37.             
  38. /**-----------------------------------------------------------------------
  39.         Name:             GreaterOf
  40.         Purpose:        Returns the Greater of two longints.
  41.     -----------------------------------------------------------------------**/
  42.     
  43. #pragma segment Utils
  44.         
  45. pascal long GreaterOf(long A, long B)
  46.  {
  47.    if (A>B)
  48.        return(A);
  49.      else
  50.        return(B);
  51.  }  /*GreaterOf*/
  52.             
  53. /**-----------------------------------------------------------------------
  54.         Name:             ShowError
  55.         Purpose:        Reports an error to the user as both string and number.
  56.     -----------------------------------------------------------------------**/
  57. #pragma segment Utils
  58.         
  59. pascal void ShowError(Str255  theError,
  60.                                           long    theErrorCode)
  61. {
  62.    short     alertResult;
  63.    Str255    theString;
  64.      OSErr     myErr;
  65.      
  66.      myErr = AEInteractWithUser(kAEDefaultTimeout, nil,nil);
  67.      
  68.      if (myErr == noErr)
  69.        {
  70.              SetCursor(&qd.arrow);
  71.              NumToString(theErrorCode, theString);
  72.              ParamText(theError, theString, (unsigned char *)"", (unsigned char *)"");
  73.              alertResult = Alert(300, nil);
  74.          }
  75. } /* ShowError */
  76.  
  77. /**-----------------------------------------------------------------------
  78.         Name:             Ours
  79.         Purpose:        Checks the frontmost window belongs to the app.
  80.     -----------------------------------------------------------------------**/
  81. #pragma segment Utils        
  82.     
  83. pascal Boolean Ours(WindowPtr aWindow)
  84.  {
  85.         if (aWindow)
  86.             if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  87.                 return(true);
  88.         return(false);
  89. } /* Ours */
  90.  
  91. /**-----------------------------------------------------------------------
  92.         Name:             SetShortMenus
  93.         Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  94.                                 Greys out the unavailable options - used when no docs open
  95.     -----------------------------------------------------------------------**/
  96. #pragma segment Utils        
  97.  
  98. pascal void SetShortMenus()
  99. { 
  100.     DeleteMenu(mfontID);
  101.     DeleteMenu(sizeID);
  102.     DeleteMenu(styleID);
  103.     DeleteMenu(mscriptID);
  104.  
  105.     DisableItem(myMenus[fileM], fmClose);
  106.     DisableItem(myMenus[fileM], fmSave);
  107.     DisableItem(myMenus[fileM], fmSaveAs);
  108.     DisableItem(myMenus[fileM], fmRevert);
  109.     DisableItem(myMenus[fileM], fmPrint);
  110.     DisableItem(myMenus[fileM], fmPageSetUp);
  111.  
  112.     /* now the unnecessary items on the edit menu */
  113.                 
  114.     DisableItem(myMenus[editM], undoCommand);
  115.     DisableItem(myMenus[editM], cutCommand);
  116.     DisableItem(myMenus[editM], copyCommand);
  117.     DisableItem(myMenus[editM], clearCommand);
  118.     DisableItem(myMenus[editM], pasteCommand);
  119.     DisableItem(myMenus[editM], selectAllCommand);
  120.  
  121.     DrawMenuBar();
  122. }  /* SetShortMenus */
  123.  
  124. /**-----------------------------------------------------------------------
  125.         Name:             SetLongMenus
  126.         Purpose:        Reinstates the full menu bar - called when first document
  127.                     opened.
  128.     -----------------------------------------------------------------------**/
  129. #pragma segment Utils        
  130.  
  131. pascal void SetLongMenus()
  132.   {
  133.         InsertMenu(myMenus[fontM], 0);
  134.         InsertMenu(myMenus[sizeM], 0);
  135.         InsertMenu(myMenus[styleM], 0);
  136.         InsertMenu(myMenus[scriptM], 0);
  137.  
  138.         EnableItem(myMenus[fileM], fmClose);
  139.         EnableItem(myMenus[fileM], fmSave);
  140.         EnableItem(myMenus[fileM], fmSaveAs);
  141.         EnableItem(myMenus[fileM], fmRevert);
  142.         EnableItem(myMenus[fileM], fmPrint);
  143.         EnableItem(myMenus[fileM], fmPageSetUp);
  144.  
  145.         /* now the necessary items on the edit menu -
  146.             many other items fixed on each pass thru the main event
  147.             loop or before the window pulled down
  148.         */
  149.         
  150.         EnableItem(myMenus[editM], selectAllCommand);
  151.  
  152.         DrawMenuBar();
  153.     }  /* SetLongMenus */
  154.  
  155. /**-----------------------------------------------------------------------
  156.         Name:             SetStyleMenu
  157.         Purpose:        Sets the style menu checking to reflect the style of the
  158.                     first character of the current selection in the given
  159.                                 document.
  160.     -----------------------------------------------------------------------**/
  161. #pragma segment Utils        
  162.         
  163. pascal void SetStyleMenu(DPtr theDoc)
  164.   {
  165.     TextStyle        theTStyle;
  166.         short       contMode;
  167.         short       i;
  168.         
  169.         contMode = doFace;
  170.         
  171.         TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  172.         
  173.         if ((contMode & doFace) != 0)
  174.             {
  175.                 CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  176.                 CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  177.                 CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  178.                 CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  179.                 CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  180.                 CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  181.                 CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  182.                 CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  183.           }
  184.         else
  185.             for (i=cPlain; i<= cExtend; i++)
  186.                 CheckItem(myMenus[styleM], i,     false);
  187.   }
  188.  
  189. /**-----------------------------------------------------------------------
  190.     Name:       SetSizeMenu
  191.     Purpose:    Outline all the items if the current font is an
  192.                 outline font. Check the size of the current selection
  193.   -----------------------------------------------------------------------**/
  194. #pragma segment Utils        
  195.  
  196. pascal void SetSizeMenu(DPtr theDoc)
  197.   {
  198.       short             i;
  199.         short                aSize;
  200.         short                max;
  201.     long                 theSize;
  202.     Str255        name;
  203.     Boolean       sizeinMenu;
  204.     Boolean       oldState;
  205.     Point         numer;
  206.     TextStyle        theStyle;
  207.         TEHandle    myText;
  208.         short       contMode;
  209.       
  210.     numer.h = 1;
  211.     numer.v = 1;
  212.  
  213.     myText = theDoc->theText;
  214.         
  215.         contMode = doSize+doFont;
  216.         
  217.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  218.         
  219.     sizeinMenu = false;
  220.     max = CountMItems(myMenus[sizeM]);
  221.         for (i = 1; i <= max - 5; i++)
  222.       {
  223.                 GetItem(myMenus[sizeM], i, (unsigned char *)&name);
  224.                 StringToNum(name, &theSize);
  225.                 aSize = (short)theSize;
  226.  
  227.                 if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  228.                     SetItemStyle(myMenus[sizeM], i, outline);
  229.                 else
  230.                     SetItemStyle(myMenus[sizeM], i, 0);
  231.  
  232.                 if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  233.                     {
  234.                         sizeinMenu = true;
  235.                         CheckItem(myMenus[sizeM], i, true);
  236.                     }
  237.                 else
  238.                     CheckItem(myMenus[sizeM], i, false);
  239.             }
  240.         
  241.             /*
  242.                 if it's not a size in the menu,and there is only one size in the
  243.               selection range check the other item
  244.             */
  245.             
  246.             if (!sizeinMenu && (contMode & doSize) != 0)
  247.               CheckItem(myMenus[sizeM], max, true);
  248.             else
  249.                 CheckItem(myMenus[sizeM], max, false);
  250.  
  251.             /*if this is an outline font, set the rest of the items to outline style*/
  252.             /*RealFont will ensure that the sizes are outlined*/
  253.  
  254.             oldState = GetOutlinePreferred();
  255.             SetOutlinePreferred(true);
  256.             for (i = max-4; i <= max; i++)
  257.                 {
  258.                     if (IsOutline(numer, numer) && (contMode & doFont)!= 0)
  259.                         SetItemStyle(myMenus[sizeM], i, outline);
  260.                     else
  261.                         SetItemStyle(myMenus[sizeM], i, 0);
  262.                 }
  263.                 
  264.             SetOutlinePreferred(oldState);
  265.     }
  266.             
  267. /**-----------------------------------------------------------------------
  268.     Name:       SetFontMenu
  269.     Purpose:    Set the font menu according to the state of
  270.                                 current selection of the supplied document.
  271.   -----------------------------------------------------------------------**/
  272. #pragma segment Utils
  273.         
  274. pascal void SetFontMenu(DPtr theDoc)
  275.   {
  276.     MenuHandle        theMHandle;
  277.     short         theNumber;
  278.     short         i;
  279.     short                max;
  280.     Str255        name;
  281.     TextStyle     theStyle;
  282.         short         contMode;
  283.  
  284.         theMHandle = GetMHandle(mfontID);
  285.  
  286.         if (gFontMItem)
  287.       CheckItem(theMHandle, gFontMItem, false);
  288.             
  289.         max = CountMItems(theMHandle);
  290.  
  291.         contMode = doFont;
  292.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  293.  
  294.         gFontMItem = 0;
  295.         
  296.     if (contMode & doFont)
  297.             for (i=1; i<=max; i++)
  298.                 {
  299.                     GetItem(theMHandle, i, (unsigned char *)&name);
  300.                     GetFNum(name, &theNumber);
  301.                     if (theNumber == theStyle.tsFont)
  302.                         gFontMItem = i;
  303.                 }
  304.  
  305.     if (gFontMItem)
  306.       CheckItem(theMHandle, gFontMItem, true);
  307.             
  308.         SetSizeMenu(theDoc);
  309.         SetStyleMenu(theDoc);
  310.     }
  311.  
  312. /**-----------------------------------------------------------------------
  313.     Name:       GetTempFileName
  314.     Purpose:    Fills newstring with a temporary file name.
  315.   -----------------------------------------------------------------------**/
  316.  
  317. #pragma segment Utils
  318.  
  319. pascal void GetTempFileName(DPtr aDoc,
  320.                             Str255 newString)
  321.  
  322.     {
  323.        Str255        s;
  324.      Str255        fileName;
  325.  
  326.         if (aDoc->everSaved == false)
  327.           PLstrcpy(fileName, (unsigned char *)"\pTEXTra");
  328.         else
  329.             PLstrcpy(fileName, aDoc->theFileName);
  330.  
  331.     /*generate a unique(ish) temporary filename*/
  332.         
  333.         if (fileName[0] > 21)
  334.           fileName[0] = 21;
  335.                 
  336.         NumToString(TickCount(), s);
  337.         
  338.         PLstrcat(fileName, s);
  339.         
  340.         PLstrcpy(newString,fileName);
  341.     }
  342.  
  343. /**-----------------------------------------------------------------------
  344.     Name:       SetText
  345.     Purpose:    Sets the text of the supplied itemNo in aDialog to 
  346.                                 theString and select it.
  347.   -----------------------------------------------------------------------**/
  348.  
  349. #pragma segment Utils
  350.  
  351. pascal void SetText(DialogPtr aDialog,
  352.                     short     itemNo,
  353.                     Str255    theString)
  354.   {
  355.     Handle      itemHandle;
  356.     Rect        box;
  357.     short       kind;
  358.     TEHandle    theTEHandle;
  359.  
  360.         GetDItem(aDialog, itemNo, &kind, &itemHandle, &box);
  361.         SetIText(itemHandle, theString);
  362.         
  363.         theTEHandle = ((DialogPeek)aDialog)->textH;
  364.  
  365.         /*set all the text to be selected*/
  366.         if (theTEHandle)
  367.             TESetSelect(0, 255, theTEHandle);
  368.     }
  369.             
  370. /**-----------------------------------------------------------------------
  371.     Name:       RetrieveText
  372.     Purpose:    Returns the text of anItem in aDialog in aString.
  373.   -----------------------------------------------------------------------**/
  374.  
  375. #pragma segment Utils
  376.  
  377. pascal void RetrieveText(DialogPtr aDialog,
  378.                                                short     anItem,
  379.                                                Str255    aString)
  380.   {
  381.      short      kind;
  382.      Rect       box;
  383.      Handle     itemHandle;
  384.  
  385.          GetDItem(aDialog, anItem, &kind, &itemHandle, &box);
  386.          GetIText(itemHandle, aString);
  387.   }
  388.  
  389. /**-----------------------------------------------------------------------
  390.     Name:       DrawDefaultOutline
  391.     Purpose:    Draws an outline around theItem.
  392.                                 Called as a useritem Proc by the dialog manager.
  393.                                 To use place a useritem over the default item in the
  394.                                 dialog and install the address of this proc as the item
  395.                                 handle.
  396.   -----------------------------------------------------------------------**/
  397.  
  398. #pragma segment Utils
  399.  
  400. pascal void DrawDefaultOutline(DialogPtr theDialog, short theItem)
  401.   {
  402.       short       kind;
  403.     Handle      itemHandle;
  404.     Rect        box;
  405.                 
  406.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  407.     PenSize(3, 3);
  408.     InsetRect(&box, - 4, - 4);
  409.     FrameRoundRect(&box, 16, 16);
  410.     PenNormal();
  411.         
  412.     }  /* DrawDefaultOutline */
  413.             
  414. /**-----------------------------------------------------------------------
  415.     Name:       AdornDefaultButton
  416.     Purpose:    Installs DrawDefaultOutline as the useritem proc
  417.                     for the given item.
  418.   -----------------------------------------------------------------------**/
  419.  
  420. #pragma segment Utils
  421.         
  422. pascal void AdornDefaultButton(DialogPtr theDialog,short theItem)
  423.   {
  424.       short       kind;
  425.     Handle      itemHandle;
  426.     Rect        box;
  427.  
  428.         GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  429.         SetDItem(theDialog, theItem, kind, (Handle)&DrawDefaultOutline, &box);
  430.   }
  431.  
  432.     /*-------  Determining of Gestalt is available ---------------*/
  433.     /*The following routines come from the Inside Mac VI recommendations*/
  434.     /*about how to find if a trap is available*/
  435.          /*
  436.             The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  437.              need to check the system version
  438.         */
  439.  
  440. pascal void GetRectOfDialogItem(DialogPtr theDialog, short theItem, Rect *theRect)
  441.     {
  442.       short       kind;
  443.     Handle      itemHandle;
  444.         
  445.         GetDItem(theDialog, theItem, &kind, &itemHandle, theRect);
  446.     }
  447.  
  448. #pragma segment Utils
  449.  
  450. pascal short NumToolboxTraps()
  451.   {
  452.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  453.             return(0x200);
  454.         else
  455.             return(0x400);
  456.     }
  457.  
  458. #pragma segment Utils
  459.  
  460. #define TrapMask  0x0800
  461.  
  462. pascal TrapType GetTrapType(short theTrap)
  463.   {
  464.         if ((theTrap & TrapMask) > 0)
  465.             return(ToolTrap);
  466.         else
  467.             return(OSTrap);
  468.     }
  469.  
  470. #pragma segment Utils
  471.  
  472. pascal Boolean TrapAvailable(short theTrap)
  473.   {
  474.         TrapType  tType;
  475.  
  476.         tType = GetTrapType(theTrap);
  477.         if (tType == ToolTrap)
  478.             {
  479.                 theTrap = theTrap & 0x07FF;
  480.                 if (theTrap >= NumToolboxTraps())
  481.                     theTrap = _Unimplemented;
  482.             }
  483.         return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  484.     }
  485.  
  486. #pragma segment Utils
  487.  
  488. #define _Gestalt 0xA1AD
  489.  
  490. pascal Boolean GestaltAvailable()
  491.   {
  492.         return(TrapAvailable(_Gestalt));
  493.     }
  494.  
  495. /**------  FeatureIsImplemented    ------------**/
  496. /*This is called to use Gestalt to determine if a feature is implemented.
  497.  This applies to only those referenced by OSType*/
  498.  
  499. #pragma segment Utils
  500.  
  501. pascal Boolean FeatureIsImplemented(OSType  theFeature,
  502.                                                           short   theTestBit)
  503.   {
  504.     OSErr     err;
  505.     long      result;
  506.  
  507.         err = Gestalt(theFeature, &result);
  508.         if (err == noErr)
  509.             if ((result & theTestBit) == theTestBit)
  510.                 return(true);
  511.                 
  512.       return(false);
  513.     }
  514.  
  515. #pragma segment Utils
  516.  
  517. pascal Boolean CheckEnvironment()
  518.   {
  519.         /*
  520.          first determine of Gestalt is available- if it isn't exit
  521.          as we only run under 7.0.  It could it present in 6.04 - so we need
  522.          to do some further checks for important features
  523.         */
  524.  
  525.         gGestaltAvailable = GestaltAvailable();
  526.         
  527.         if (!gGestaltAvailable)
  528.             return(false);
  529.  
  530.     /*first check if the Alias manager is present*/
  531.                 
  532.         gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr,
  533.                                                                                                          gestaltAliasMgrPresent);
  534.             
  535.         /*check for the AppleEvents manager - we certainly can't work without it*/
  536.         
  537.         gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,
  538.                                                                                                          gestaltAppleEventsPresent);
  539.             
  540.         /*check for the Outline fonts*/
  541.         
  542.         gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr,
  543.                                                                                                          gestaltOutlineFonts);
  544.         
  545.         return (gAliasManagerImplemented   &&
  546.                         gAppleEventsImplemented    &&
  547.                         gOutlineFontsImplemented);
  548.                                 
  549.     }  /* CheckEnvironment */
  550.             
  551.     /*
  552.         DoPageSetup returns true if the page setup of the document is altered
  553.     */
  554.     
  555.     pascal Boolean DoPageSetup(DPtr theDoc)
  556.         {
  557.             Boolean result = false;
  558.                 
  559.                 if (theDoc)
  560.                     {
  561.                         PrOpen();
  562.                         result =  PrStlDialog(theDoc->thePrintSetup);
  563.                         PrClose();
  564.                     }
  565.                     
  566.                 return(result);
  567.         }  /* DoPageSetup */
  568.  
  569. /*
  570.     Name:    CtrlKeyPressed
  571.     Purpose: Returns true if control key pressed during event
  572. */
  573. pascal Boolean CtrlKeyPressed(const EventRecord *theEvent)
  574.     {
  575.         return((theEvent->modifiers & controlKey) != 0);
  576.     }
  577.     
  578. /*
  579.     Name:    OptionKeyPressed
  580.     Purpose: Returns true if option key pressed during event
  581. */
  582. pascal Boolean OptionKeyPressed(const EventRecord *theEvent)
  583.     {
  584.         return((theEvent->modifiers & optionKey) != 0);
  585.     }
  586.